import uuid
from django.db.models import Max
from BloodSpiderAPI import models
from BloodSpiderModel.DjangoResponseTool.response_dict import response_dict, get_page
from PublicFunction.MoneyUtils import safe_to_number


def version_create(request):
    """
    创建版本信息
    请求方式: POST
    参数:
        version: 版本号 (必填, 语义化版本号格式: x.y.z, 例如1.4.2或1.12.24)
        status: 版本状态 (必填, 1-正常, 2-维护)
        download_url: 版本下载地址 (必填, 字符串)
        version_desc: 版本描述 (选填, 字符串)
    返回:
        创建的版本信息
    """
    import re
    
    try:
        # 获取参数
        version = request.POST.get('version')
        status = int(request.POST.get('status'))
        download_url = request.POST.get('download_url')
        version_desc = request.POST.get('version_desc', '')
        
        # 参数验证
        if not version:
            return response_dict(code=1, message="版本号参数错误, 不能为空")
        
        # 语义化版本号格式验证 (x.y.z)
        version_pattern = r'^\d+\.\d+\.\d+$'
        if not re.match(version_pattern, version):
            return response_dict(code=1, message="版本号格式错误, 必须符合语义化版本规范(x.y.z)")
        
        # 解析版本号为数字部分
        major_str, minor_str, patch_str = version.split('.')
        major = int(major_str)
        minor = int(minor_str)
        patch = int(patch_str)
        
        if status not in [1, 2]:
            return response_dict(code=1, message="版本状态参数错误, 仅支持1(正常)或2(维护)")
        if not download_url:
            return response_dict(code=1, message="版本下载地址参数错误, 不能为空")
        
        # 版本号验证: 必须大于当前最新版本号
        latest_version = models.Version.objects.first()  # 已按-major/-minor/-patch排序
        if latest_version:
            latest_major = latest_version.major
            latest_minor = latest_version.minor
            latest_patch = latest_version.patch
            
            # 比较版本号
            if major < latest_major:
                return response_dict(code=1, message=f"新版本号必须大于当前最新版本号: {latest_version.version}")
            elif major == latest_major:
                if minor < latest_minor:
                    return response_dict(code=1, message=f"新版本号必须大于当前最新版本号: {latest_version.version}")
                elif minor == latest_minor:
                    if patch <= latest_patch:
                        return response_dict(code=1, message=f"新版本号必须大于当前最新版本号: {latest_version.version}")
        
        # 创建版本记录
        new_version = models.Version.objects.create(
            version=version,
            major=major,
            minor=minor,
            patch=patch,
            status=status,
            download_url=download_url,
            version_desc=version_desc
        )
        
        # 构造返回数据
        return response_dict(data={
            "version_id": new_version.version_id,
            "version": new_version.version,
            "status": new_version.status,
            "version_desc": new_version.version_desc,
            "download_url": new_version.download_url,
            "create_time": new_version.create_time.strftime("%Y-%m-%d %H:%M:%S"),
            "update_time": new_version.update_time.strftime("%Y-%m-%d %H:%M:%S")
        }, message="版本创建成功")
    except Exception as e:
        return response_dict(code=1, message=f"版本创建失败: {str(e)}")


def version_list(request):
    """
    获取全部版本信息
    请求方式: GET
    参数:
        sort_by: 排序字段 (选填, 支持version/-version/create_time/-create_time, 默认:-version)
        page: 页码 (选填, 默认:1)
        page_size: 每页数量 (选填, 默认:10)
    返回:
        版本列表, 支持分页
    """
    try:
        # 获取参数
        sort_by = request.GET.get("sort_by", "-version")
        page = int(request.GET.get("page", 1))
        page_size = int(request.GET.get("page_size", 10))
        
        # 排序字段验证
        valid_sort_fields = ['version', '-version', 'create_time', '-create_time']
        if sort_by not in valid_sort_fields:
            return response_dict(code=1, message=f"无效的排序字段, 仅支持{','.join(valid_sort_fields)}")
        
        # 处理语义化版本排序
        if sort_by == 'version':
            order_by_fields = ['major', 'minor', 'patch']
        elif sort_by == '-version':
            order_by_fields = ['-major', '-minor', '-patch']
        else:
            order_by_fields = [sort_by]
        
        # 查询数据并排序
        versions = models.Version.objects.all().order_by(*order_by_fields)
        
        # 分页处理
        paginated_data = get_page(versions, page_size=page_size, page_num=page)
        if not paginated_data:
            return response_dict(code=1, message="没有更多数据", data=[])
        
        # 转换为字典列表
        version_list = []
        for version in paginated_data["page"]["object_list"]:
            version_list.append({
                "version_id": version.version_id,
                "version": version.version,
                "status": version.status,
                "version_desc": version.version_desc,
                "download_url": version.download_url,
                "create_time": version.create_time.strftime("%Y-%m-%d %H:%M:%S"),
                "update_time": version.update_time.strftime("%Y-%m-%d %H:%M:%S")
            })
        
        # 构造返回数据
        return response_dict(data=version_list, message="获取版本列表成功")
    except ValueError:
        return response_dict(code=1, message="页码或每页数量参数错误, 必须为整数")
    except Exception as e:
        return response_dict(code=1, message=f"获取版本列表失败: {str(e)}")


def version_detail(request):
    """
    获取单个版本信息
    请求方式: GET
    参数:
        version_id: 版本ID (选填, 与version二选一)
        version: 版本号 (选填, 与version_id二选一, 语义化版本号格式: x.y.z)
    返回:
        版本详细信息
    """
    try:
        version_id = request.GET.get("version_id")
        version_num = request.GET.get("version")
        
        # 参数验证: version_id或version必须提供一个
        if not version_id and not version_num:
            return response_dict(code=1, message="版本ID或版本号参数错误, 必须至少提供一个")
        
        # 查询版本信息
        if version_id:
            # 验证version_id是否为有效的UUID格式
            try:
                uuid_obj = uuid.UUID(version_id)
            except ValueError:
                return response_dict(code=1, message="版本ID格式错误, 必须为有效的UUID")
            # 根据version_id查询
            version = models.Version.objects.get(version_id=version_id)
        else:
            # 根据版本号查询 (直接使用字符串比较)
            version = models.Version.objects.get(version=version_num)
        
        # 构造返回数据
        return response_dict(data={
            "version_id": version.version_id,
            "version": version.version,
            "status": version.status,
            "version_desc": version.version_desc,
            "download_url": version.download_url,
            "create_time": version.create_time.strftime("%Y-%m-%d %H:%M:%S"),
            "update_time": version.update_time.strftime("%Y-%m-%d %H:%M:%S")
        }, message="获取版本详情成功")
    except models.Version.DoesNotExist:
        return response_dict(code=1, message="版本信息不存在")
    except ValueError:
        return response_dict(code=1, message="版本ID或版本号参数错误, 格式不正确")
    except Exception as e:
        return response_dict(code=1, message=f"获取版本详情失败: {str(e)}")


def version_current(request):
    """
    获取当前版本号
    请求方式: GET
    参数: 无
    返回:
        当前最新版本信息
    """
    try:
        # 查询最新版本 (版本号最大)
        current_version = models.Version.objects.order_by('-version').first()
        
        # 检查是否存在版本记录
        if not current_version:
            return response_dict(code=1, message="当前系统尚未创建任何版本信息")
        
        # 构造返回数据
        return response_dict(data={
            "version_id": current_version.version_id,
            "version": current_version.version,
            "status": current_version.status,
            "version_desc": current_version.version_desc,
            "download_url": current_version.download_url,
            "create_time": current_version.create_time.strftime("%Y-%m-%d %H:%M:%S"),
            "update_time": current_version.update_time.strftime("%Y-%m-%d %H:%M:%S")
        }, message="获取当前版本成功")
    except Exception as e:
        return response_dict(code=1, message=f"获取当前版本失败: {str(e)}")